package com.timo.redis.util;

import com.timo.redis.model.ExpireTimeUnit;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;

import javax.annotation.Resource;
import java.util.Collection;
import java.util.Date;
import java.util.concurrent.TimeUnit;

/**
 * @Description: Redis 工具类
 * <p>
 * key命令操作 | String数据操作 | Hash数据操作 | List数据操作 | Set数据操作 | zSet数据操作
 * @Author: timo
 * @Date: 2019/8/28 16:56
 */
@Slf4j
@Component
public class RedisUtil {

    /**
     * hash 操作
     */
    @Resource
    HashOperations<String, String, Object> hashOperations;
    /**
     * 字符串操作类型
     */
    @Resource
    ValueOperations<String, String> valueOperations;
    /**
     * list集合 操作类型
     */
    @Resource
    ListOperations<String, Object> listOperations;
    /**
     * set集合 操作类型
     */
    @Resource
    SetOperations<String, Object> setOperations;
    /**
     * 有序set集合操作类型
     */
    @Resource
    ZSetOperations<String, Object> zSetOperations;
    /**
     * key 操作命令
     */
    @Resource
    private RedisTemplate redisTemplate;

    //------------------- key 操作 ---------------------

    /**
     * 根据Key删除存在redis中的数据
     *
     * @param key 键<br>
     * @return boolean
     * @Author timo <br/>
     * @Date 2019/8/28 17:19 <br/>
     */
    public boolean delete(String key) {
        Assert.isTrue(StringUtils.isNotEmpty(key), "key is null");
        return redisTemplate.delete(key);
    }

    /**
     * 根据Keys批量删除存在redis中的数据
     *
     * @param keys 键<br>
     * @return boolean
     * @Author timo <br/>
     * @Date 2019/8/28 17:19 <br/>
     */
    public Long delete(Collection<String> keys) {
        Long delete = redisTemplate.delete(keys);
        return delete;
    }

    /**
     * 根据key判断是否还存在
     *
     * @param key <br>
     * @return boolean
     * @Author timo <br/>
     * @Date 2019/8/28 17:21 <br/>
     */
    public boolean exist(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 给key设置过期时间
     *
     * @param key      <br>
     * @param timeUnit <br>
     * @return void
     * @Author timo <br/>
     * @Date 2019/8/28 17:23 <br/>
     */
    public void expire(String key, ExpireTimeUnit timeUnit) {
        Assert.isTrue(StringUtils.isNotEmpty(key), "key is null");
        Assert.notNull(timeUnit, "timeUnie is null");
        Assert.isTrue(timeUnit.getExpire() > 0, "expire time must gt 0");
        Assert.notNull(timeUnit.getTimeUnit(), "timeUnit is null");

        redisTemplate.expire(key, timeUnit.getExpire(), timeUnit.getTimeUnit());
    }


    /**
     * 根据key设置过期时间
     *
     * @param key  键<br>
     * @param date 失效时间<br>
     * @return void
     * @Author timo <br/>
     * @Date 2019/8/28 17:25 <br/>
     */
    public void expire(String key, Date date) {
        redisTemplate.expireAt(key, date);
    }

    /**
     * 获取key的过期时间
     *
     * @param key      键<br>
     * @param timeUnit 获取的时间类型<br>
     * @return java.lang.Long
     * @Author timo <br/>
     * @Date 2019/8/28 17:28 <br/>
     */
    public Long getExpire(String key, TimeUnit timeUnit) {
        return redisTemplate.getExpire(key, timeUnit);
    }


    /**
     * 移除key的失效时间将数据变为永久存储
     *
     * @param key <br>
     * @return java.lang.Boolean
     * @Author timo <br/>
     * @Date 2019/8/28 17:29 <br/>
     */
    public Boolean persist(String key) {
        return redisTemplate.persist(key);
    }

    /**
     * 修改key的名称
     *
     * @param oldKey 旧的key<br>
     * @param newKey 新的key<br>
     * @return void
     * @Author timo <br/>
     * @Date 2019/8/28 17:31 <br/>
     */
    public void rename(String oldKey, String newKey) {
        redisTemplate.rename(oldKey, newKey);
    }

    /**
     * 仅当 newkey 不存在时，将 oldKey 改名为 newkey
     *
     * @param oldKey 旧的key<br>
     * @param newKey 新的key<br>
     * @return void
     * @Author timo <br/>
     * @Date 2019/8/28 17:34 <br/>
     */
    public void renameIfAbsent(String oldKey, String newKey) {
        redisTemplate.renameIfAbsent(oldKey, newKey);
    }


    /**
     * 获取key的数据类型
     *
     * @param key <br>
     * @return org.springframework.data.redis.connection.DataType
     * @Author timo <br/>
     * @Date 2019/8/28 17:38 <br/>
     */
    public DataType type(String key) {
        return redisTemplate.type(key);
    }


    //------------------- String数据操作 ---------------------
    /*
    1	String get(String key)	获取指定key的值
    2	String getRange(String key, long start, long end)	返回key中字符串值的子字符
    3	String getAndSet(String key, String value)	将key的值设为value，并返回key旧值
    4	Boolean getBit(String key, long offset)	对key所储存的值，获取指定位置上的bit
    5	List multiGet(Collection keys)	批量获取
    添加相关
    6	void set(String key, String value)	设置指定key的值
    7	boolean setBit(String key, long offset, boolean value)	设置指定位置上的ASCII码
    8	void setEx(String key,String value,long timeout,TimeUnit unit)	将值value关联到key，并设置key过期时间
    9	boolean setIfAbsent(String key, String value)	只有在 key 不存在时设置 key 的值
    10	void setRange(String key, String value, long offset)	用value覆写key的值，从偏移量offset开始
    11	void multiSet(Map<String,String> maps)	批量添加
    12	boolean multiSetIfAbsent(Map<String,String> maps)	批量添加，仅当所有key都不存在
    其他方法
    13	Integer append(String key, String value)	追加到末尾
    14	Long incrBy(String key, long increment)	增加(自增长), 负数则为自减
    15	Double incrByFloat(String key, double increment)	增加(自增长), 负数则为自减
    16	Long size(String key)	获取字符串的长度
     */

    /**
     * 保存字符串的值
     *
     * @param k 键<br>
     * @param v 键值<br>
     * @return void
     * @Author timo <br/>
     * @Date 2019/8/28 17:41 <br/>
     */
    public void vset(String k, String v) {
        valueOperations.set(k, v);
    }

    public void vset(String k, String v, ExpireTimeUnit timeUnit) {
        valueOperations.set(k, v);
        expire(k, timeUnit);
    }

    /**
     * setnx
     *
     * @param key <br>
     * @param v   <br>
     * @return void
     * @Author timo <br/>
     * @Date 2019/8/29 10:04 <br/>
     */
    public void vsetnx(String key, String v) {
        valueOperations.setIfAbsent(key, v);
        expire(key, new ExpireTimeUnit());
    }


    /**
     * 根据键获取数据
     *
     * @param k <br>
     * @return java.lang.String
     * @Author timo <br/>
     * @Date 2019/8/28 17:42 <br/>
     */
    public String vget(String k) {
        return valueOperations.get(k);
    }

    /**
     * 根据key获取截取字符串的的内容,如果改key不存在的时候就会返回null
     *
     * @param k     键<br>
     * @param start 起始位置<br>
     * @param end   结束位置<br>
     * @return java.lang.String
     * @Author timo <br/>
     * @Date 2019/8/28 17:45 <br/>
     */
    public String vgetRange(String k, int start, int end) {
        if (!exist(k)) {
            return null;
        }
        return valueOperations.get(k, start, end);
    }

    //------------------- Hash数据操作 ---------------------
    /*
    1	Object hGet(String key, String field)	获取存储在哈希表中指定字段的值
    2	Map hGetAll(String key)	获取所有给定字段的值
    3	List hMultiGet(String key, Collection fields)	获取所有给定字段的值
    添加相关
    4	void hPut(String key, String hashKey, String value)	添加字段
    5	void hPutAll(String key, Map maps)	添加多个字段
    6	Boolean hPutIfAbsent(String key,String hashKey,String value)	仅当hashKey不存在时才设置
    其他方法
    7	Long hDelete(String key, Object... fields)	删除一个或多个哈希表字段
    8	boolean hExists(String key, String field)	查看哈希表key中指定的字段是否存在
    9	Long hIncrBy(String key, Object field, long increment)	为哈希表key中指定字段的值增加increment
    10	Double hIncrByFloat(String key, Object field, double delta)	为哈希表key中指定字段的值增加increment
    11	Set hKeys(String key)	获取所有哈希表中的字段
    12	Long hSize(String key)	获取哈希表中字段的数量
    13	List hValues(String key)	获取哈希表中所有值
    14	Cursor hScan(String key, ScanOptions options)	迭代哈希表中的键值对
    引入序列化依赖
    com.dyuproject.protostuff protostuff-core 1.0.8
    com.dyuproject.protostuff protostuff-runtime 1.0.8
    15	getListCache(final String key, Class targetClass)	获取缓存中的List，targetClass是序列化的类
    16	putListCacheWithExpireTime(String key, List objList, final long expireTime)	把List放到缓存，expireTime是过期策略
     */
    //------------------- List数据操作 ---------------------
    /*
    1	String lIndex(String key, long index)	通过索引获取列表中的元素
    2	List lRange(String key, long start, long end)	获取列表指定范围内的元素
    添加相关
    3	Long lLeftPush(String key, String value)	存储在list头部
    4	Long lLeftPushAll(String key, String... value)	存储在list头部
    5	Long lLeftPushAll(String key, Collection value)	存储在list头部
    6	Long lLeftPushIfPresent(String key, String value)	当list存在的时候才加入
    7	lLeftPush(String key, String pivot, String value)	如果pivot存在,再pivot前面添加
    8	Long lRightPush(String key, String value)	存储在list尾部
    9	Long lRightPushAll(String key, String... value)	存储在list尾部
    10	Long lRightPushAll(String key, Collection value)	存储在list尾部
    11	Long lRightPushIfPresent(String key, String value)	当list存在的时候才加入
    12	lRightPush(String key, String pivot, String value)	在pivot元素的右边添加值
    13	void lSet(String key, long index, String value)	通过索引设置列表元素的值
    删除相关
    14	String lLeftPop(String key)	移出并获取列表的第一个元素
    15	String lBLeftPop(String key,long timeout,TimeUnit unit)	移出并获取第一个元素,没有则阻塞直到超时或有为止
    16	String lRightPop(String key)	移除并获取列表最后一个元素
    17	String lBRightPop(String key,long timeout,TimeUnit unit)	移出并获取最后个元素,没有则阻塞直到超时或有为止
    18	String lRightPopAndLeftPush(String sKey,String dKey)	移除最后一个元素并加到另一个列表并返回
    19	String lBRightPopAndLeftPush(sKey,dKey,timeout,unit)	移除最后个元素并加到另个列表并返回,阻塞超时或有
    20	Long lRemove(String key, long index, String value)	删除集合中值等于value得元素
    21	void lTrim(String key, long start, long end)	裁剪list
    其他方法
    22	Long lLen(String key)	获取列表长度
     */

    public <T> void lset(String key, Collection<T> list) {
        listOperations.leftPushAll(key, list);
    }

    public void lLeftPush(String k, String v) {
        listOperations.leftPush(k, v);
        expire(k, new ExpireTimeUnit());
    }

    public void lLeftPush(String k, String v, ExpireTimeUnit expireTimeUnit) {
        listOperations.leftPush(k, v);
        expire(k, expireTimeUnit);
    }


    public <T> T lget(String key, Class<T> cls) {
        return (T) listOperations.range(key, 0, -1);
    }

    //------------------- Set数据操作 ---------------------
    /*
    1	Set sMembers(String key)	获取集合所有元素
    2	Long sSize(String key)	获取集合大小
    3	Boolean sIsMember(String key, Object value)	判断集合是否包含value
    4	String sRandomMember(String key)	随机获取集合中的一个元素
    5	List sRandomMembers(String key, long count)	随机获取集合count个元素
    6	Set sDistinctRandomMembers(String key, long count)	随机获取count个元素并去除重复的
    7	Cursor sScan(String key, ScanOptions options)	使用迭代器获取元素
    8	Set sIntersect(String key, String otherKey)	获取两个集合的交集
    9	Set sIntersect(String key, Collection otherKeys)	获取key集合与多个集合的交集
    10	Long sIntersectAndStore(String key, String oKey, String dKey)	key集合与oKey的交集存储到dKey中
    11	Long sIntersectAndStore(String key,Collection oKeys,String dKey)	key与多个集合的交集存储到dKey中
    12	Set sUnion(String key, String otherKeys)	获取两个集合的并集
    13	Set sUnion(String key, Collection otherKeys)	获取key集合与多个集合的并集
    14	Long sUnionAndStore(String key, String otherKey, String destKey)	key集合与oKey的并集存储到dKey中
    15	Long sUnionAndStore(String key,Collection oKeys,String dKey)	key与多个集合的并集存储到dKey中
    16	Set sDifference(String key, String otherKey)	获取两个集合的差集
    17	Set sDifference(String key, Collection otherKeys)	获取key集合与多个集合的差集
    18	Long sDifference(String key, String otherKey, String destKey)	key与oKey集合的差集存储到dKey中
    19	Long sDifference(String key,Collection otherKeys,String dKey)	key与多个集合的差集存储到dKey中
    添加相关
    20	Long sAdd(String key, String... values)	添加
    删除相关
    21	Long sRemove(String key, Object... values)	移除
    22	String sPop(String key)	随机移除一个元素
    23	Boolean sMove(String key, String value, String destKey)	将key集合中value移到destKey中
     */
    //------------------- zSet数据操作 ---------------------
    /*
    1	Set zRange(String key, long start, long end)	获取元素,小到大排序,s开始e结束位置
    2	Set<TypedTuple> zRangeWithScores(String key, long start, long end)	获取集合元素, 并且把score值也获取
    3	Set zRangeByScore(String key, double min, double max)	根据score范围查询元素,从小到大排序
    4	Set<TypedTuple> zRangeByScoreWithScores(key,double min,double max)	根据score范围查询元素,并返回score
    5	Set zRangeByScoreWithScores(key,double min,max,long start,end)	根据score查询元素,s开始e结束位置
    6	Set zReverseRange(String key, long start, long end)	获取集合元素, 从大到小排序
    7	Set<TypedTuple> zReverseRangeWithScores(key, long start, long end)	获取元素,从大到小排序,并返回score
    8	Set zReverseRangeByScore(String key, double min, double max)	根据score范围查询元素,从大到小排序
    9	Set zReverseRangeByScoreWithScores(key,double min,double max)	根据score查询,大到小排序返回score
    10	Set zReverseRangeByScore(key, double min, max, long start, end)	根据score查询,大到小,s开始e结束
    11	Long zRank(String key, Object value)	返回元素在集合的排名,score由小到大
    12	Long zReverseRank(String key, Object value)	返回元素在集合的排名,score由大到小
    13	Long zCount(String key, double min, double max)	根据score值范围获取集合元素的数量
    14	Long zSize(String key)	获取集合大小
    15	Long zZCard(String key)	获取集合大小
    16	Double zScore(String key, Object value)	获取集合中value元素的score值
    17	Long zUnionAndStore(String key, String otherKey, String destKey)	获取key和oKey的并集并存储在dKey中
    18	Long zUnionAndStore(String key,Collection otherKeys,String dKey)	获取key和多个集合并集并存在dKey中
    19	Long zIntersectAndStore(String key, String otherKey, String destKey)	获取key和oKey交集并存在destKey中
    20	Long zIntersectAndStore(String key,Collection oKeys,String dKey)	获取key和多个集合交集并存在dKey中
    21	Cursor<TypedTuple> zScan(String key, ScanOptions options)	使用迭代器获取
    添加相关
    22	Boolean zAdd(String key, String value, double score)	添加元素,zSet按score由小到大排列
    23	Long zAdd(String key, Set<TypedTuple> values)	批量添加,TypedTuple使用见下面介绍
    删除相关
    24	Long zRemove(String key, Object... values)	移除
    25	Double zIncrementScore(String key, String value, double delta)	增加元素的score值,并返回增加后的值
    26	Long zRemoveRange(String key, long start, long end)	移除指定索引位置的成员
    27	Long zRemoveRangeByScore(String key, double min, double max)	根据指定的score值的范围来移除成员
     */


    //------------------- 私有方法的处理-------------

    private void checkKeyIsNotNull(String key) {
        Assert.isTrue(StringUtils.isNotEmpty(key));
    }
}
